﻿using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Linq;
using System.Text;
using System.Windows.Forms;
using Microsoft.VisualBasic;

/*
 * 2d sprite editor 
 * 
*/


namespace WindowsFormsApplication1
{
    
      
 
    public partial class Form1 : Form
    {
        //public Animazione m_Animazione = new Animazione(100, 200);
        public Animazione m_Animazione;
        public List<Animazione> m_Grafica = new List<Animazione>();
        public int m_idAnimazioneSelezionata=0;
        Image immagine;        
        Color m_ColoreFotogrammaSelezionato;
        Color m_ColoreFotogrammaNonSelezionato;
        int m_FattoreZoom;

        System.IO.TextReader tr;
        System.IO.TextWriter tw;

        public Form1()
        {
            InitializeComponent();
            Aggiorna_Label();
            m_ColoreFotogrammaSelezionato = Color.Red;
            m_ColoreFotogrammaNonSelezionato = Color.Yellow;
            m_FattoreZoom = 1;
            //System.Drawing.Drawing2D.pro
            //panelTexture.BackgroundImage
            LoadConfigurazione("EditorAnimazioni_cfg.txt");
        }

        private void LoadConfigurazione(string sFileConfigurazione)
        {
            System.IO.TextReader tr = new System.IO.StreamReader(sFileConfigurazione);
            string strRiga;
            string strValore;
            int iValore;
            int r, g, b;

            //tipo_file=EDITOR_ANIMAZIONI_CFG
            strRiga = tr.ReadLine();
            strValore=GetValoreStr(strRiga);
            if (strValore != "EDITOR_ANIMAZIONI_CFG")
                throw new Exception("Formato del file non valido!");
            
            //versione=1.1.0
            strRiga = tr.ReadLine();
            strValore = GetValoreStr(strRiga);
            if (strValore != "1.1.0")
                throw new Exception("Versione del file non valida!");

            //colore_fotogramma_selezionato_r=" + m_ColoreFotogrammaSelezionato.R.ToString());
            strRiga = tr.ReadLine();
            iValore = GetValoreInt(strRiga);
            r = iValore;

            //tr.ReadLine("colore_fotogramma_selezionato_g=" + m_ColoreFotogrammaSelezionato.G.ToString());
            strRiga = tr.ReadLine();
            iValore = GetValoreInt(strRiga);
            g = iValore;

            //tr.ReadLine("colore_fotogramma_selezionato_b=" + m_ColoreFotogrammaSelezionato.B.ToString());
            strRiga = tr.ReadLine();
            iValore = GetValoreInt(strRiga);
            b = iValore;

            m_ColoreFotogrammaSelezionato=Color.FromArgb(r, g, b);

            //tr.ReadLine("colore_fotogramma_non_selezionato_r=" + m_ColoreFotogrammaNonSelezionato.R.ToString());
            strRiga = tr.ReadLine();
            iValore = GetValoreInt(strRiga);
            r = iValore;

            //tr.ReadLine("colore_fotogramma_non_selezionato_g=" + m_ColoreFotogrammaNonSelezionato.G.ToString());
            strRiga = tr.ReadLine();
            iValore = GetValoreInt(strRiga);
            g = iValore;

            // tr.ReadLine("colore_fotogramma_non_selezionato_b=" + m_ColoreFotogrammaNonSelezionato.B.ToString());
            strRiga = tr.ReadLine();
            iValore = GetValoreInt(strRiga);
            b = iValore;

            m_ColoreFotogrammaNonSelezionato = Color.FromArgb(r, g, b);
           
            tr.Close();
        }

        private void SalvaConfigurazione(string sFileConfigurazione)
        {
            System.IO.TextWriter tw = new System.IO.StreamWriter(sFileConfigurazione);
            tw.WriteLine("tipo_file=EDITOR_ANIMAZIONI_CFG");
            tw.WriteLine("versione=1.1.0");
            tw.WriteLine("colore_fotogramma_selezionato_r=" + m_ColoreFotogrammaSelezionato.R.ToString());
            tw.WriteLine("colore_fotogramma_selezionato_g=" + m_ColoreFotogrammaSelezionato.G.ToString());
            tw.WriteLine("colore_fotogramma_selezionato_b=" + m_ColoreFotogrammaSelezionato.B.ToString());
            tw.WriteLine("colore_fotogramma_non_selezionato_r=" + m_ColoreFotogrammaNonSelezionato.R.ToString());
            tw.WriteLine("colore_fotogramma_non_selezionato_g=" + m_ColoreFotogrammaNonSelezionato.G.ToString());
            tw.WriteLine("colore_fotogramma_non_selezionato_b=" + m_ColoreFotogrammaNonSelezionato.B.ToString());
            tw.Close();
        }

        private void Aggiorna_Label()
        {
            //try
            //{
                if (m_Animazione != null)
                {
                    if (m_Animazione.GetPxFotogramma() < 0)
                        m_Animazione.SetPxFotogramma(0);

                    if (m_Animazione.GetPyFotogramma() < 0)
                        m_Animazione.SetPyFotogramma(0);

                    if ((m_Animazione.GetPxFotogramma() + m_Animazione.GetDxFotogrammi()) > immagine.Width)
                        m_Animazione.SetPxFotogramma(immagine.Width - m_Animazione.GetDxFotogrammi());

                    if ((m_Animazione.GetPyFotogramma() + m_Animazione.GetDyFotogrammi()) > immagine.Height)
                        m_Animazione.SetPyFotogramma(immagine.Height - m_Animazione.GetDyFotogrammi());

                    numericUpDownDxFot.Maximum = immagine.Width;
                    numericUpDownDyFot.Maximum = immagine.Height;

                    label4.Text = "Fotogramma " + (m_Animazione.GetFotogrammaSelezionato() + 1) + "/" + m_Animazione.GetNumeroFotogrammi();// +"px(" + m_Animazione.GetPxFotogramma() + ") py(" + m_Animazione.GetPyFotogramma() + ")";
                    label12.Text = m_Animazione.GetPyFotogramma().ToString();
                    label11.Text = m_Animazione.GetPxFotogramma().ToString();
                    label22.Text = ((char)(m_Animazione.GetFotogrammaSelezionato())).ToString();
                    labelInfoAnimazione.Text = (m_idAnimazioneSelezionata + 1) + "/" + m_Grafica.Count();
                    numericUpDownDxFot.Value = m_Animazione.GetDxFotogrammi();
                    numericUpDownDyFot.Value = m_Animazione.GetDyFotogrammi();
                    numericUpDownFPS.Value = (int)m_Animazione.GetFrameRate();
                    timer1.Interval = (int)(1 / m_Animazione.GetFrameRate() * 1000);
                    textBoxAnimazione.Text = m_Animazione.GetNome();
                    //panel4.AutoScrollMinSize = new Size(m_Animazione.GetDxFotogrammi(), m_Animazione.GetDyFotogrammi());
                    panelPreview.Size = new Size(m_Animazione.GetDxFotogrammi(), m_Animazione.GetDyFotogrammi());


                    //panelTexture.Size = new Size(immagine.Width * m_FattoreZoom, immagine.Height * m_FattoreZoom);


                    //collision
                    int idboxs = m_Animazione.GetCollisionBoxSelezionato();
                    numericUpDownBoxDx.Value = m_Animazione.GetDxCollisionBox(idboxs);
                    numericUpDownBoxDy.Value = m_Animazione.GetDyCollisionBox(idboxs);
                    label13.Text = "Box " + (idboxs + 1).ToString() + "/" + m_Animazione.CollisionBoxCount();
                    label17.Text = "px: " + m_Animazione.GetPxCollisionBox(idboxs);
                    label18.Text = "py: " + m_Animazione.GetPyCollisionBox(idboxs);

                    //disegno
                    //panelPreview.Invalidate();
                    panelTexture.Invalidate();
                }
            //}
           // catch(Exception e)
            //{
            //    MessageBox.Show(e.Message, "Attenzione!");                
            //}
        }        


        

        private void button18_Click(object sender, EventArgs e)
        {
            int pxAttuale=m_Animazione.GetPxFotogramma();
            m_Animazione.SetPxFotogramma(pxAttuale - (int)numericUpDownPixel.Value);
            Aggiorna_Label();
        }

        private void button16_Click(object sender, EventArgs e)
        {
            int pxAttuale = m_Animazione.GetPxFotogramma();
            m_Animazione.SetPxFotogramma(pxAttuale + (int)numericUpDownPixel.Value);
            Aggiorna_Label();
        }

        private void button17_Click(object sender, EventArgs e)
        {
            int pyAttuale = m_Animazione.GetPyFotogramma();
            m_Animazione.SetPyFotogramma(pyAttuale - (int)numericUpDownPixel.Value);
            Aggiorna_Label();
        }

        private void button15_Click(object sender, EventArgs e)
        {
            int pyAttuale = m_Animazione.GetPyFotogramma();
            m_Animazione.SetPyFotogramma(pyAttuale + (int)numericUpDownPixel.Value);
            Aggiorna_Label();
        }

        private void AbilitaInterfaccia(bool b)
        {
            panelPreview.Enabled = b;            
            panelTexture.Enabled = b;
            buttonAddFotogramma.Enabled = b;
            buttonDelFotogramma.Enabled = b;
            buttonFotPrecedente.Enabled = b;
            buttonFotSuccessivo.Enabled = b;
            numericUpDownPixel.Enabled = b;
            numericUpDownDxFot.Enabled = b;
            numericUpDownDyFot.Enabled = b;
            numericUpDownFPS.Enabled = b;
            buttonUPfot.Enabled = b;
            buttonSXfot.Enabled = b;
            buttonDXfot.Enabled = b;
            buttonDWfot.Enabled = b;
            buttonAddAnimazione.Enabled = b;
            buttonDelAnimazione.Enabled = b;
            buttonNextAnim.Enabled = b;
            buttonPrevAnim.Enabled = b;
            buttonZoom1X.Enabled = b;
            buttonZoom2X.Enabled = b;
            buttonZoom4X.Enabled = b;
            buttonZoom8X.Enabled = b;
            textBoxAnimazione.Enabled = b;
            animazioneToolStripMenuItem.Enabled = b;
            fotogrammaToolStripMenuItem.Enabled = b;
            buttonSXanim.Enabled = b;
            buttonDXanim.Enabled = b;
            buttonUPanim.Enabled = b;
            buttonDWanim.Enabled = b;
            numericUpDownAnimazione.Enabled = b;

            buttonBoxAdd.Enabled = b;
            buttonBoxDel.Enabled = b;
            buttonBoxDw.Enabled = b;
            buttonBoxDx.Enabled = b;
            buttonBoxNext.Enabled = b;
            buttonBoxPrec.Enabled = b;
            buttonBoxSx.Enabled = b;
            buttonBoxUp.Enabled = b;
            numericUpDownBoxDx.Enabled = b;
            numericUpDownBoxDy.Enabled = b;
            numericUpDownBoxPixel.Enabled = b;
            caricaToolStripMenuItem1.Enabled = b;
            salvaToolStripMenuItem.Enabled = b;
            caricaSingolaToolStripMenuItem.Enabled = b;
            salvaSelezionataToolStripMenuItem.Enabled = b;
            salvaConfigurazioneToolStripMenuItem.Enabled = b;
            //inportaDaToolStripMenuItem.Enabled = b;
            step1FormattaToolStripMenuItem.Enabled = b;
        }

        private void Form1_Load(object sender, EventArgs e)
        {
            try
            {
                AbilitaInterfaccia(false);
                this.SetStyle(
                    ControlStyles.UserPaint |
                    ControlStyles.AllPaintingInWmPaint |
                    ControlStyles.DoubleBuffer, true);

                //this.panelPreviewpanelPreview. .SetStyle(
                //    ControlStyles.UserPaint |
                //    ControlStyles.AllPaintingInWmPaint |
                //    ControlStyles.DoubleBuffer, true);

                //this.SetStyle(
                //    ControlStyles.UserPaint |
                //    ControlStyles.AllPaintingInWmPaint |
                //    ControlStyles.DoubleBuffer, true);

            }
            catch (Exception ecc)
            {
                MessageBox.Show(ecc.Message);
            }
        }

        private void panel2_Paint(object sender, PaintEventArgs e)
        {
            if (panelPreview.Enabled)
            {
                                
                e.Graphics.InterpolationMode = System.Drawing.Drawing2D.InterpolationMode.NearestNeighbor;
                //e.Graphics.DrawImageUnscaledAndClipped(panelPreview.BackgroundImage, new Rectangle(0, 0, panelPreview.BackgroundImage.Width, panelPreview.BackgroundImage.Height));

                Rectangle r = new Rectangle();

                int id = m_Animazione.GetFotogrammaSelezionatoPreview();
                int px = m_Animazione.GetPxFotogramma(id);
                int py = m_Animazione.GetPyFotogramma(id);

                int dx = m_Animazione.GetDxFotogrammi() ;
                int dy = m_Animazione.GetDyFotogrammi() ;

                panelPreview.Size = new Size(dx * 1, dy * 1);

                r.X = px * 1;
                r.Y = py * 1;
                r.Width = dx * 1;
                r.Height = dy * 1;

                r.X = 0;
                r.Y = 0;
                e.Graphics.Clear(Color.Black);
                e.Graphics.DrawImage(panelPreview.BackgroundImage, r, px, py, dx, dy, GraphicsUnit.Pixel);

                for (int b = 0; b < m_Animazione.CollisionBoxCount(); b++)
                {
                    int b_px = m_Animazione.GetPxCollisionBox(b) * 1;
                    int b_py = m_Animazione.GetPyCollisionBox(b) * 1;
                    int b_dx = (m_Animazione.GetDxCollisionBox(b) - 1) * 1;
                    int b_dy = (m_Animazione.GetDyCollisionBox(b) - 1) * 1;

                    Pen p;

                    if (b != m_Animazione.GetCollisionBoxSelezionato())
                        p = new Pen(m_ColoreFotogrammaNonSelezionato, 1);
                    else
                        p = new Pen(m_ColoreFotogrammaSelezionato, 1);

                    e.Graphics.DrawRectangle
                    (
                            p,
                            b_px,
                            b_py,
                            b_dx,
                            b_dy
                    );
                }
            }
        }

        private void timer1_Tick(object sender, EventArgs e)
        {
            m_Animazione.SelezionaFotogrammaSuccessivoPreview();
            Aggiorna_Label();
            panelPreview.Invalidate();           
            
        }

        public class CollisionBox
        {
            private int m_pxCollisionBox;
            private int m_pyCollisionBox;
            private int m_dxCollisionBox;
            private int m_dyCollisionBox;
            //private int m_dxFotogramma;
            //private int m_dyFotogramma;

            public CollisionBox(int pxbox, int pybox, int dxbox, int dybox)//, int dxfot, int dyfot)
            {
                m_pxCollisionBox = pxbox;
                m_pyCollisionBox = pybox;
                m_dxCollisionBox = dxbox;
                m_dyCollisionBox = dybox;
                //m_dxFotogramma = dxfot;
                //m_dyFotogramma = dyfot;
            }

            //x

            public void SetPx(int px,int dxf)
            {
                if (px < 0)
                    m_pxCollisionBox = 0;
                else if ((px + m_dxCollisionBox) > dxf)
                    m_pxCollisionBox = dxf - m_dxCollisionBox;
                else
                    m_pxCollisionBox = px;
            }

            public void SetDx(int dx, int dxf)
            {
                if ((m_pxCollisionBox + dx) > dxf)
                    m_dxCollisionBox = dxf - m_pxCollisionBox;
                else
                    m_dxCollisionBox = dx;
            }

            public int GetPx()
            {
                return m_pxCollisionBox;
            }

            public int GetDx()
            {
                return m_dxCollisionBox;
            }

            //y

            public void SetPy(int py, int dyf)
            {

                if (py < 0)
                    m_pyCollisionBox = 0;
                else if ((py + m_dyCollisionBox) > dyf)
                    m_pyCollisionBox = dyf-m_dyCollisionBox-1;
                else
                    m_pyCollisionBox = py;
            }

            public void SetDy(int dy, int dyf)
            {
                if ((m_pyCollisionBox + dy) > dyf)
                    m_dyCollisionBox = dyf - m_pyCollisionBox;
                else
                    m_dyCollisionBox = dy;
            }

            public int GetPy()
            {
                return m_pyCollisionBox;
            }

            public int GetDy()
            {
                return m_dyCollisionBox;
            }
        }


        public class Fotogramma
        {
            private int m_pxFotogramma;
            private int m_pyFotogramma;
            //private int m_dxFotogramma;
            //private int m_dyFotogramma;
            //private int m_idCollisionBox;
            //private List<CollisionBox> m_CollisionBox = new List<CollisionBox>();

            public Fotogramma(int px, int py)//,int dx, int dy)
            {
                m_pxFotogramma = px;
                m_pyFotogramma = py;
                //m_dxFotogramma = dx;
                //m_dyFotogramma = dy;
                //m_idCollisionBox = 0;
            }

            public int GetPx()
            {
                return m_pxFotogramma;
            }

            public void SetPx(int px)
            {
                m_pxFotogramma = px;
            }

            public int GetPy()
            {
                return m_pyFotogramma;
            }

            public void SetPy(int py)
            {
                m_pyFotogramma = py;
            }

            //public void SelNextCollisionBox()
            //{
            //    m_idCollisionBox++;
            //    if (m_idCollisionBox >= m_CollisionBox.Count())
            //        m_idCollisionBox = m_CollisionBox.Count() - 1;
            //}

            //public void SelPrevCollisionBox()
            //{
            //    m_idCollisionBox--;
            //    if (m_idCollisionBox < 0)
            //        m_idCollisionBox = 0;
            //}

            //public void InsertCollisionBox(int px, int py, int dx, int dy)
            //{
            //    CollisionBox c = new CollisionBox(px, py, dx, dy);//, m_dxFotogramma, m_dyFotogramma);
            //    m_CollisionBox.Insert(m_idCollisionBox, c);
            //}

            //public void DelCollisionBox()
            //{
            //    m_CollisionBox.RemoveAt(m_idCollisionBox);
            //    SelPrevCollisionBox();
            //}

            //public int GetPxCollisionBox(int id)
            //{
            //    return m_CollisionBox[id].GetPx();
            //}

            //public int GetPyCollisionBox(int id)
            //{
            //    return m_CollisionBox[id].GetPy();
            //}

            //public int GetDxCollisionBox(int id)
            //{
            //    return m_CollisionBox[id].GetDx();
            //}

            //public int GetDyCollisionBox(int id)
            //{
            //    return m_CollisionBox[id].GetDy();
            //}
            
        }

        

        public class Animazione
        {

            private int m_DxFotogrammi;
            private int m_DyFotogrammi;
            private float m_FrameRate;
            private int m_idFotogrammaSelezionato;
            private int m_idFotogrammaSelezionatoPreview;
            private int m_idFotogrammaSelezionatoCollisionBox;
            private int m_idCollisionBoxSelezionato;
            private List<Fotogramma> m_Fotogrammi = new List<Fotogramma>();
            private List<CollisionBox> m_CollisionBox = new List<CollisionBox>();
            private string m_Nome;

            public Animazione(int dx, int dy)
            {
                m_DxFotogrammi = dx;
                m_DyFotogrammi = dy;
                m_idFotogrammaSelezionato = 0;
                m_idFotogrammaSelezionatoPreview = 0;
                m_FrameRate = 10;
                //AggiungiFotogramma(0, 0, 0);
                //AggiungiCollisionBox(0);
                m_idCollisionBoxSelezionato = 0;
            }

            public int GetCollisionBoxSelezionato()
            {
                return m_idCollisionBoxSelezionato;
            }

            public int CollisionBoxCount()
            {
                return m_CollisionBox.Count();
            }

            public int GetPxCollisionBox(int idx)
            {
                return m_CollisionBox[idx].GetPx();
            }

            public int GetPyCollisionBox(int idx)
            {
                return m_CollisionBox[idx].GetPy();
            }

            public int GetDxCollisionBox(int idx)
            {
                return m_CollisionBox[idx].GetDx();
            }

            public int GetDyCollisionBox(int idx)
            {
                return m_CollisionBox[idx].GetDy();
            }

            public void SetPxCollisionBox(int id,int px)
            {
                m_CollisionBox[id].SetPx(px, m_DxFotogrammi);
            }

            public void SetPyCollisionBox(int id,int py)
            {
                m_CollisionBox[id].SetPy(py,m_DyFotogrammi);
            }

            public void SetDxCollisionBox(int id, int dx)
            {
                m_CollisionBox[id].SetDx(dx, m_DxFotogrammi);
            }

            public void SetDyCollisionBox(int id, int dy)
            {
                m_CollisionBox[id].SetDy(dy, m_DyFotogrammi);
            }

            public void SelezionaCollisionBoxSuccessivo()
            {
                m_idCollisionBoxSelezionato++;
                if (m_idCollisionBoxSelezionato >= m_CollisionBox.Count())
                    m_idCollisionBoxSelezionato = m_CollisionBox.Count() - 1;
            }

            public void SelezionaCollisionBoxPrecedente()
            {
                m_idCollisionBoxSelezionato--;
                if (m_idCollisionBoxSelezionato<0)
                    m_idCollisionBoxSelezionato = 0;
            }

            public void AggiungiCollisionBox(int idx)
            {
                CollisionBox b = new CollisionBox(GetDxFotogrammi() / 4, GetDyFotogrammi() / 4, GetDxFotogrammi() / 2, GetDyFotogrammi() / 2);
                //int id = m_idCollisionBoxSelezionato;
                m_CollisionBox.Insert(idx,b);
            }

            public void CancellaCollisionBox()
            {
                m_CollisionBox.RemoveAt(m_idCollisionBoxSelezionato);
            }

            public void SetNome(string s)
            {
                m_Nome = s;
            }

            public string GetNome()
            {
                return m_Nome;
            }

            public int GetDxFotogrammi()
            {
                return m_DxFotogrammi;
            }

            public int GetDyFotogrammi()
            {
                return m_DyFotogrammi;
            }

            public int GetPxFotogramma()
            {
                return m_Fotogrammi[m_idFotogrammaSelezionato].GetPx();
            }

            public int GetPxFotogramma(int id)
            {
                return m_Fotogrammi[id].GetPx();
            }

            public int GetPyFotogramma()
            {
                return m_Fotogrammi[m_idFotogrammaSelezionato].GetPy();
            }

            public int GetPyFotogramma(int id)
            {
                return m_Fotogrammi[id].GetPy();
            }

            public void SetPxFotogramma(int px)
            {
                m_Fotogrammi[m_idFotogrammaSelezionato].SetPx(px);
            }

            public void SetPxFotogramma(int idx_fotogramma,int px)
            {
                m_Fotogrammi[idx_fotogramma].SetPx(px);
            }

            public void SetPyFotogramma(int py)
            {
                m_Fotogrammi[m_idFotogrammaSelezionato].SetPy(py);
            }

            public void SetPyFotogramma(int idx_fotogramma, int py)
            {
                m_Fotogrammi[idx_fotogramma].SetPy(py);
            }

            public void AggiungiFotogramma(int posizione, int px, int py)
            {
                Fotogramma f = new Fotogramma(px, py);//,m_DxFotogrammi,m_DyFotogrammi);
                m_Fotogrammi.Insert(posizione, f);
            }

            public void CanellaFotogramma()
            {
                m_Fotogrammi.RemoveAt(m_idFotogrammaSelezionato);                
                SelezionaFotogrammaPrecedente();
            }

            public void SetFrameRate(float f)
            {
                m_FrameRate = f;
            }

            public float GetFrameRate()
            {
                return m_FrameRate;
            }

            public void SelezionaFotogrammaSuccessivo()
            {
                m_idFotogrammaSelezionato++;
                int n = GetNumeroFotogrammi();
                if (m_idFotogrammaSelezionato >= n)
                    m_idFotogrammaSelezionato = n-1;
            }

            public void SelezionaFotogrammaSuccessivoPreview()
            {
                m_idFotogrammaSelezionatoPreview++;
                int n = GetNumeroFotogrammi();
                if (m_idFotogrammaSelezionatoPreview >= n)
                    m_idFotogrammaSelezionatoPreview = 0;
            }

            public void SelezionaFotogrammaPrecedente()
            {
                m_idFotogrammaSelezionato--;
                if (m_idFotogrammaSelezionato < 0)
                    m_idFotogrammaSelezionato = 0;
            }            

            public int GetFotogrammaSelezionato()
            {
                return m_idFotogrammaSelezionato;
            }

            public int GetFotogrammaSelezionatoPreview()
            {
                return m_idFotogrammaSelezionatoPreview;
            }            

            public int GetNumeroFotogrammi()
            {
                return m_Fotogrammi.Count();
            }

            public void SetDxFotogrammi(int dx)
            {
                m_DxFotogrammi = dx;
                for (int b = 0; b < m_CollisionBox.Count; b++)
                {
                    int dx_b = m_CollisionBox[b].GetDx();
                    m_CollisionBox[b].SetDx(dx_b, m_DxFotogrammi);
                }
            }

            public void SetDyFotogrammi(int dy)
            {
                m_DyFotogrammi = dy;
                for (int b = 0; b < m_CollisionBox.Count; b++)
                {
                    int dy_b = m_CollisionBox[b].GetDy();
                    m_CollisionBox[b].SetDy(dy_b, m_DyFotogrammi);
                }
            }

        }

        private void button7_Click(object sender, EventArgs e)
        {
            int idx = m_Animazione.GetFotogrammaSelezionato();
            int px = m_Animazione.GetPxFotogramma();
            int py = m_Animazione.GetPyFotogramma();
            m_Animazione.AggiungiFotogramma(idx+1, px, py);
            m_Animazione.SelezionaFotogrammaSuccessivo();
            Aggiorna_Label();
        }

        private void button8_Click(object sender, EventArgs e)
        {
            if (m_Animazione.GetNumeroFotogrammi() > 1)
            {
                m_Animazione.CanellaFotogramma();
                Aggiorna_Label();
            }
        }

        private void button10_Click(object sender, EventArgs e)
        {
            m_Animazione.SelezionaFotogrammaPrecedente();
            Aggiorna_Label();

        }

        private void button11_Click(object sender, EventArgs e)
        {
            m_Animazione.SelezionaFotogrammaSuccessivo();
            Aggiorna_Label();
        }

        private void caricaToolStripMenuItem_Click(object sender, EventArgs e)
        {
            try
            {
                //openFileDialog1.Filter = "Immagine Bitmap (*.bmp)|*.bmp|Immagine PNG (*.png)|*.png";
                openFileDialog1.Filter = "Immagine PNG (*.png)|*.png";
                DialogResult dr=openFileDialog1.ShowDialog();
                if(dr==DialogResult.OK)
                {
                    string sFile = openFileDialog1.FileName;                
                    immagine = Image.FromFile(sFile);
                    /*
                    string sMessaggio = "ATTENZIONE! L'immagine deve essere di risoluzione 256x256, 512x512, 1024x1024, 2048x2048 o 4096x4096";
                    if (immagine.Width != immagine.Height)
                    {
                        DialogResult dr1=MessageBox.Show("La texture non è quadrata! Procedere comunque?", "Attenzione!", MessageBoxButtons.YesNo);
                        if(dr1!=DialogResult.OK)
                            throw (new Exception(sMessaggio));
                    }
                     * */
                    /*
                    if (immagine.Width != 256 && immagine.Width != 512 && immagine.Width != 1024 && immagine.Width != 2048 && immagine.Width != 4096)
                    {
                        DialogResult dr2 = MessageBox.Show("La texture non è grande con potenza 2! Procedere comunque?", "Attenzione!", MessageBoxButtons.YesNo);
                        if (dr2 != DialogResult.OK)
                            throw (new Exception(sMessaggio));
                    }
                     * */
                    panelTexture.BackgroundImage = immagine;
                    panelPreview.BackgroundImage = immagine;
                    panelTexture.Size = new Size(immagine.Width, immagine.Height);
                    m_Animazione = new Animazione(immagine.Width / 10, immagine.Height / 10);
                    m_Animazione.AggiungiFotogramma(0, 0, 0);
                    m_Animazione.AggiungiCollisionBox(0);
                    m_Grafica.Add(m_Animazione);
                    AbilitaInterfaccia(true);
                    Aggiorna_Label();
                    timer1.Start();
                    //panelTexture. .AutoScrollMinSize = new Size(immagine.Width, immagine.Height);
                    //panelTexture.Size = new Size(immagine.Width, immagine.Height);
                }
            }
            catch (Exception ecc)
            {
                MessageBox.Show(ecc.Message);
            }

        }
        

        private void numericUpDownDXfot_ValueChanged(object sender, EventArgs e)
        {
            m_Animazione.SetDxFotogrammi((int)numericUpDownDxFot.Value);
            Aggiorna_Label();
        }

        private void numericUpDownDYfot_ValueChanged(object sender, EventArgs e)
        {
            m_Animazione.SetDyFotogrammi((int)numericUpDownDyFot.Value);
            Aggiorna_Label();
        }

        private void numericUpDownFPS_ValueChanged(object sender, EventArgs e)
        {
            m_Animazione.SetFrameRate((float)(numericUpDownFPS.Value));
            Aggiorna_Label();
        }

        private void panel3_Paint(object sender, PaintEventArgs e)
        {
            if (panelTexture.Enabled)
            {
                panelTexture.Size = new Size(panelTexture.BackgroundImage.Width * m_FattoreZoom, panelTexture.BackgroundImage.Height * m_FattoreZoom);
                e.Graphics.InterpolationMode = System.Drawing.Drawing2D.InterpolationMode.NearestNeighbor;
                e.Graphics.DrawImageUnscaledAndClipped(panelTexture.BackgroundImage, new Rectangle(0, 0, panelTexture.BackgroundImage.Width * m_FattoreZoom, panelTexture.BackgroundImage.Height * m_FattoreZoom));

                int n = m_Animazione.GetNumeroFotogrammi();
                int dx = m_Animazione.GetDxFotogrammi();
                int dy = m_Animazione.GetDyFotogrammi();
                dx--;
                dy--;
                int px = 0;
                int py = 0;
                int s = m_Animazione.GetFotogrammaSelezionato();
                Pen penna;                
                for (int id = 0; id < n; id++)
                {
                    px = m_Animazione.GetPxFotogramma(id);
                    py = m_Animazione.GetPyFotogramma(id);
                    if (id != s)
                        penna = new Pen(m_ColoreFotogrammaNonSelezionato, m_FattoreZoom);
                    else
                        penna = new Pen(m_ColoreFotogrammaSelezionato, m_FattoreZoom);
                    
                    e.Graphics.DrawRectangle(
                            penna, 
                            px * m_FattoreZoom + m_FattoreZoom / 2, 
                            py * m_FattoreZoom + m_FattoreZoom / 2, 
                            dx * m_FattoreZoom,//- m_FattoreZoom / 2, 
                            dy * m_FattoreZoom);// - m_FattoreZoom / 2);
                    
                }
            }          

        }

        private void button1_Click(object sender, EventArgs e)
        {
            m_FattoreZoom = 1;
            Aggiorna_Label();
        }

        private void button4_Click(object sender, EventArgs e)
        {
            m_Grafica.Add(new Animazione(panelTexture.Size.Width/4, panelTexture.Size.Height/4));            
            m_idAnimazioneSelezionata = m_Grafica.Count - 1;
            m_Animazione = m_Grafica[m_idAnimazioneSelezionata];
            m_Animazione.AggiungiFotogramma(0, 0, 0);
            m_Animazione.AggiungiCollisionBox(0);
            Aggiorna_Label();
        }

        private void button5_Click(object sender, EventArgs e)
        {
            if (m_Grafica.Count() > 1)
            {
                m_Grafica.RemoveAt(m_idAnimazioneSelezionata);
                m_idAnimazioneSelezionata--;
                if (m_idAnimazioneSelezionata < 0)
                    m_idAnimazioneSelezionata = 0;
                m_Animazione = m_Grafica[m_idAnimazioneSelezionata];
                Aggiorna_Label();
            }
        }

        private void button6_Click(object sender, EventArgs e)
        {
            m_idAnimazioneSelezionata--;
            if (m_idAnimazioneSelezionata < 0)
                m_idAnimazioneSelezionata = 0;
            m_Animazione = m_Grafica[m_idAnimazioneSelezionata];
            Aggiorna_Label();

        }

        private void button7_Click_1(object sender, EventArgs e)
        {
            m_idAnimazioneSelezionata++;
            if (m_idAnimazioneSelezionata >= m_Grafica.Count)
                m_idAnimazioneSelezionata = m_Grafica.Count - 1;
            m_Animazione = m_Grafica[m_idAnimazioneSelezionata];
            Aggiorna_Label();
        }

        private void textBox1_TextChanged(object sender, EventArgs e)
        {
            m_Animazione.SetNome(textBoxAnimazione.Text);
        }

        private void salvaToolStripMenuItem_Click(object sender, EventArgs e)
        {
            try
            {
                saveFileDialog1.Filter = "File di animazioni (*.txt)|*.txt";
                saveFileDialog1.ShowDialog();
                string sFile = saveFileDialog1.FileName;
                System.IO.TextWriter tw = new System.IO.StreamWriter(sFile);
                tw.WriteLine("tipo_file=EDITOR_ANIMAZIONI");
                tw.WriteLine("versione_engine=1.1");
                tw.WriteLine("dimensione_texture="+ immagine.Width.ToString());
                tw.WriteLine("numero_animazioni=" + m_Grafica.Count().ToString());

                for (int a = 0; a < m_Grafica.Count(); a++)
                {
                    //spaziatura
                    tw.WriteLine("");

                    //informazioni
                    tw.WriteLine("nome_animazione=" + m_Grafica[a].GetNome());

                    //fotogrammi
                    tw.WriteLine("dx_fotogrammi=" + m_Grafica[a].GetDxFotogrammi().ToString());
                    tw.WriteLine("dy_fotogrammi=" + m_Grafica[a].GetDyFotogrammi().ToString());
                    tw.WriteLine("fps=" + m_Grafica[a].GetFrameRate().ToString());
                    tw.WriteLine("n_fotogrammi=" + m_Grafica[a].GetNumeroFotogrammi().ToString());
                    for (int f = 0; f < m_Grafica[a].GetNumeroFotogrammi(); f++)
                    {
                        tw.WriteLine("px_fotogramma_"+f.ToString()+"=" + m_Grafica[a].GetPxFotogramma(f).ToString());
                        tw.WriteLine("py_fotogramma_"+f.ToString()+"=" + m_Grafica[a].GetPyFotogramma(f).ToString());
                    }

                    //collision
                    tw.WriteLine("n_collisionbox=" + m_Grafica[a].CollisionBoxCount().ToString());
                    for (int b = 0; b < m_Grafica[a].CollisionBoxCount(); b++)
                    {
                        tw.WriteLine("px_box_"+b.ToString()+"=" + m_Grafica[a].GetPxCollisionBox(b).ToString());
                        tw.WriteLine("py_box_"+b.ToString()+"=" + m_Grafica[a].GetPyCollisionBox(b).ToString());
                        tw.WriteLine("dx_box_" + b.ToString() + "=" + m_Grafica[a].GetDxCollisionBox(b).ToString());
                        tw.WriteLine("dy_box_" + b.ToString() + "=" + m_Grafica[a].GetDyCollisionBox(b).ToString());
                    }
                }
                
                tw.Close();

                MessageBox.Show("Animazioni salvate correttamente.", "Animazioni", MessageBoxButtons.OK, MessageBoxIcon.Information);
            }
            catch (Exception ecc)
            {
                MessageBox.Show(ecc.Message);
            }

        }

        private int GetValoreInt(string s)
        {
            int id=s.IndexOf('=')+1;
            string valore = s.Substring(id, s.Length-id);
            return Convert.ToInt32(valore);
        }

        private string GetValoreStr(string s)
        {
            int id = s.IndexOf('=')+1;
            string valore = s.Substring(id, s.Length-id);
            return valore;
        }

        private void caricaToolStripMenuItem1_Click(object sender, EventArgs e)
        {    
            try
            {
                openFileDialog1.Filter= "File di animazioni (*.txt)|*.txt";
                openFileDialog1.ShowDialog();
                string sFile = openFileDialog1.FileName;
                System.IO.TextReader tr = new System.IO.StreamReader(sFile);

                string strValore="";
                int intValore=-1;

                //tipo_file
                strValore = GetValoreStr(tr.ReadLine());
                if (strValore != "EDITOR_ANIMAZIONI")
                    throw new KeyNotFoundException();

                //versione_engine
                strValore = GetValoreStr(tr.ReadLine());
                if (strValore != "1.1")
                    throw new KeyNotFoundException();

                //dimensione_texture
                intValore = GetValoreInt(tr.ReadLine());
                if (intValore != immagine.Width)
                    throw new KeyNotFoundException();

                m_Grafica.Clear();

                //numero_animazioni
                int iNumeroAnimazioni = GetValoreInt(tr.ReadLine());
                for (int a = 0; a < iNumeroAnimazioni; a++)
                {
                    
                    tr.ReadLine();
                    string sNomeAnimazione = GetValoreStr(tr.ReadLine());
                    int dx_fotogrammi = GetValoreInt(tr.ReadLine());
                    int dy_fotogrammi = GetValoreInt(tr.ReadLine());
                    int fps = GetValoreInt(tr.ReadLine());
                    int n_fotogrammi = GetValoreInt(tr.ReadLine());

                    Animazione animazione = new Animazione(dx_fotogrammi, dy_fotogrammi);
                    animazione.SetNome(sNomeAnimazione);
                    animazione.SetFrameRate(fps);

                    for (int f = 0; f < n_fotogrammi; f++)
                    {
                        int px_fotogramma= GetValoreInt(tr.ReadLine());
                        int py_fotogramma= GetValoreInt(tr.ReadLine());
                        animazione.AggiungiFotogramma(f, px_fotogramma, py_fotogramma);
                    }
                    int n_collisionbox = GetValoreInt(tr.ReadLine());
                    for (int b = 0; b < n_collisionbox; b++)
                    {
                        int px_box = GetValoreInt(tr.ReadLine());
                        int py_box = GetValoreInt(tr.ReadLine());
                        int dx_box = GetValoreInt(tr.ReadLine());
                        int dy_box = GetValoreInt(tr.ReadLine());
                        animazione.AggiungiCollisionBox(b);
                        animazione.SetPxCollisionBox(b,px_box);
                        animazione.SetPyCollisionBox(b, py_box);
                        animazione.SetDxCollisionBox(b, dx_box);
                        animazione.SetDyCollisionBox(b, dy_box);
                    }

                    m_Grafica.Add(animazione);
                }
                tr.Close();
                m_idAnimazioneSelezionata = 0;
                m_Animazione = m_Grafica[m_idAnimazioneSelezionata];
                Aggiorna_Label();
                MessageBox.Show("Animazioni lette correttamente.", "Animazioni", MessageBoxButtons.OK, MessageBoxIcon.Information);
            }
            catch (Exception ecc)
            {
                MessageBox.Show(ecc.Message);
            }
        }

        private void coloreSelezionatoToolStripMenuItem_Click(object sender, EventArgs e)
        {
            colorDialog1.ShowDialog();
            m_ColoreFotogrammaSelezionato = colorDialog1.Color;
            panelTexture.Invalidate();
        }

        private void coloreNonSelezionatoToolStripMenuItem_Click(object sender, EventArgs e)
        {
            colorDialog1.ShowDialog();
            m_ColoreFotogrammaNonSelezionato = colorDialog1.Color;
            panelTexture.Invalidate();
        }

        private void buttonZoom2X_Click(object sender, EventArgs e)
        {
            m_FattoreZoom = 2;
            Aggiorna_Label();
        }

        private void buttonZoom4X_Click(object sender, EventArgs e)
        {
            m_FattoreZoom = 4;
            Aggiorna_Label();

        }

        private void buttonZoom8X_Click(object sender, EventArgs e)
        {
            m_FattoreZoom = 8;
            Aggiorna_Label();
        }

        private void textureToolStripMenuItem_Click(object sender, EventArgs e)
        {

        }

        //public class DoubleBufferPanel : Panel
        //{
        //    public DoubleBufferPanel()
        //    {
        //        // Set the value of the double-buffering style bits to true.
        //        this.SetStyle(ControlStyles.DoubleBuffer |
        //        ControlStyles.UserPaint |
        //        ControlStyles.AllPaintingInWmPaint,
        //        true);

        //        this.UpdateStyles();
        //    }
        //}

        public class DoubleBufferPanel : Panel
        {
            public DoubleBufferPanel()
            {
                // Set the value of the double-buffering style bits to true.
                this.SetStyle(ControlStyles.DoubleBuffer |
                ControlStyles.UserPaint |
                ControlStyles.AllPaintingInWmPaint,
                true);

                this.UpdateStyles();
            }
        }

        private void buttonSXanim_Click(object sender, EventArgs e)
        {
            int i = (int)numericUpDownAnimazione.Value;
            int f = m_Animazione.GetNumeroFotogrammi();
            for (int c = 0; c < f; c++)
            {
                int px=m_Animazione.GetPxFotogramma(c);
                px = px - i;
                m_Animazione.SetPxFotogramma(c, px);
            }
            Aggiorna_Label();
        }

        private void buttonDXanim_Click(object sender, EventArgs e)
        {
            int i = (int)numericUpDownAnimazione.Value;
            int f = m_Animazione.GetNumeroFotogrammi();
            for (int c = 0; c < f; c++)
            {
                int px = m_Animazione.GetPxFotogramma(c);
                px = px + i;
                m_Animazione.SetPxFotogramma(c, px);
            }
            Aggiorna_Label();
        }

        private void buttonUPanim_Click(object sender, EventArgs e)
        {
            int i = (int)numericUpDownAnimazione.Value;
            int f = m_Animazione.GetNumeroFotogrammi();
            for (int c = 0; c < f; c++)
            {
                int py = m_Animazione.GetPyFotogramma(c);
                py = py - i;
                m_Animazione.SetPyFotogramma(c, py);
            }
            Aggiorna_Label();
        }

        private void buttonDWanim_Click(object sender, EventArgs e)
        {
            int i = (int)numericUpDownAnimazione.Value;
            int f = m_Animazione.GetNumeroFotogrammi();
            for (int c = 0; c < f; c++)
            {
                int py = m_Animazione.GetPyFotogramma(c);
                py = py + i;
                m_Animazione.SetPyFotogramma(c, py);
            }
            Aggiorna_Label();
        }

        private void splitContainer2_Panel1_Paint(object sender, PaintEventArgs e)
        {
            if (panelPreview.Enabled)
            {
                Rectangle r = new Rectangle();

                int id = m_Animazione.GetFotogrammaSelezionatoPreview();
                //id = m_Animazione.GetNumeroFotogrammi() - 1;
                int px = m_Animazione.GetPxFotogramma(id);
                int py = m_Animazione.GetPyFotogramma(id);

                int dx = m_Animazione.GetDxFotogrammi();
                int dy = m_Animazione.GetDyFotogrammi();

                r.X = px;
                r.Y = py;
                r.Width = dx;
                r.Height = dy;

                r.X = 0;
                r.Y = 0;
                //e.Graphics.DrawImage(panelPreview.BackgroundImage, r, px, py, dx, dy, GraphicsUnit.Pixel);
                e.Graphics.DrawImage(immagine, r, px, py, dx, dy, GraphicsUnit.Pixel);

                /*
                e.Graphics.DrawRectangle(
                            new Pen(m_ColoreFotogrammaNonSelezionato, m_FattoreZoom),
                            px * m_FattoreZoom + m_FattoreZoom / 2,
                            py * m_FattoreZoom + m_FattoreZoom / 2,
                            dx * m_FattoreZoom, //- m_FattoreZoom / 2, 
                            dy * m_FattoreZoom);// - m_FattoreZoom / 2);
                 */

                e.Graphics.DrawRectangle(
                            new Pen(m_ColoreFotogrammaNonSelezionato, m_FattoreZoom),
                            0,
                            0,
                            10,
                            10);// - m_FattoreZoom / 2);







            }
        }

        private void button13_Click(object sender, EventArgs e)
        {
            int id = m_Animazione.GetCollisionBoxSelezionato();
            m_Animazione.AggiungiCollisionBox(id+1);
            m_Animazione.SelezionaCollisionBoxSuccessivo();
            Aggiorna_Label();
        }

        private void button1_Click_1(object sender, EventArgs e)
        {

        }

        private void button16_Click_1(object sender, EventArgs e)
        {
            if (m_Animazione.CollisionBoxCount() > 1)
            {
                m_Animazione.CancellaCollisionBox();
                m_Animazione.SelezionaCollisionBoxPrecedente();
                Aggiorna_Label();
            }
        }

        private void button15_Click_1(object sender, EventArgs e)
        {
            m_Animazione.SelezionaCollisionBoxPrecedente();
            Aggiorna_Label();
        }

        private void button14_Click(object sender, EventArgs e)
        {
            m_Animazione.SelezionaCollisionBoxSuccessivo();
            Aggiorna_Label();
        }

        private void buttonBoxUp_Click(object sender, EventArgs e)
        {
            int id = m_Animazione.GetCollisionBoxSelezionato();
            int py= m_Animazione.GetPyCollisionBox(id);
            py = py - (int)numericUpDownBoxPixel.Value;
            m_Animazione.SetPyCollisionBox(id,py);
            Aggiorna_Label();
        }

        private void buttonBoxSx_Click(object sender, EventArgs e)
        {
            int id = m_Animazione.GetCollisionBoxSelezionato();
            int px = m_Animazione.GetPxCollisionBox(id);
            px = px - (int)numericUpDownBoxPixel.Value;
            m_Animazione.SetPxCollisionBox(id, px);
            Aggiorna_Label();
        }

        private void buttonBoxDx_Click(object sender, EventArgs e)
        {
            int id = m_Animazione.GetCollisionBoxSelezionato();
            int px = m_Animazione.GetPxCollisionBox(id);
            px = px + (int)numericUpDownBoxPixel.Value;
            m_Animazione.SetPxCollisionBox(id, px);
            Aggiorna_Label();
        }

        private void buttonBoxDw_Click(object sender, EventArgs e)
        {
            int id = m_Animazione.GetCollisionBoxSelezionato();
            int py = m_Animazione.GetPyCollisionBox(id);
            py = py + (int)numericUpDownBoxPixel.Value;
            m_Animazione.SetPyCollisionBox(id, py);
            Aggiorna_Label();
        }        

        private void numericUpDownBoxDx_ValueChanged(object sender, EventArgs e)
        {
            int id = m_Animazione.GetCollisionBoxSelezionato();
            int dx = (int)numericUpDownBoxDx.Value;
            m_Animazione.SetDxCollisionBox(id, dx);
            Aggiorna_Label();
        }

        private void numericUpDownBoxDy_ValueChanged(object sender, EventArgs e)
        {
            int id = m_Animazione.GetCollisionBoxSelezionato();
            int dy = (int)numericUpDownBoxDy.Value;
            m_Animazione.SetDyCollisionBox(id, dy);
            Aggiorna_Label();
        }

        private void caricaSingolaToolStripMenuItem_Click(object sender, EventArgs e)
        {
            MessageBox.Show("Funzionalità non implementata");
        }

        private void salvaSelezionataToolStripMenuItem_Click(object sender, EventArgs e)
        {
            MessageBox.Show("Funzionalità non implementata");
        }

        private void salvaConfigurazioneToolStripMenuItem_Click(object sender, EventArgs e)
        {
            try
            {                
                SalvaConfigurazione("EditorAnimazioni_cfg.txt");
                MessageBox.Show("Configurazione salvata correttamente");
            }
            catch (Exception ecc)
            {
                MessageBox.Show(ecc.Message);
            }
        }

        private void aboutToolStripMenuItem_Click(object sender, EventArgs e)
        {
            MessageBox.Show("Funzionalità non implementata");
        }

        private void salvaInSingoleImmaginiToolStripMenuItem_Click(object sender, EventArgs e)
        {
            try
            {
                saveFileDialog1.Filter = "File di immagini (*.png)|*.png";
                saveFileDialog1.ShowDialog();
                string sFile = saveFileDialog1.FileName;
                for (int f = 0; f < m_Animazione.GetNumeroFotogrammi(); f++)
                {
                    int px = m_Animazione.GetPxFotogramma(f);
                    int py = m_Animazione.GetPyFotogramma(f);
                    int dx = m_Animazione.GetDxFotogrammi();
                    int dy = m_Animazione.GetDyFotogrammi();
                    Rectangle section;
                    section = new Rectangle(0,0, dx, dy);                    
                    Bitmap bmp = new Bitmap(dx, dy);
                    Graphics g = Graphics.FromImage(bmp);
                    g.DrawImage(panelTexture.BackgroundImage, section, px, py, dx, dy, GraphicsUnit.Pixel);
                    g.Dispose();
                    //System.IO.FileInfo fi= new System.IO.FileInfo(saveFileDialog1.FileName);
                    string sPath = System.IO.Path.GetDirectoryName(sFile);
                    string sNomeFile = System.IO.Path.GetFileNameWithoutExtension(sFile);
                    string sEstensione = System.IO.Path.GetExtension(sFile);
                    string sok = sPath + "\\" + sNomeFile + "_" + f.ToString() + sEstensione;
                    bmp.Save(sok, System.Drawing.Imaging.ImageFormat.Png);
                    //bmp.Save(sok);                    
                }                
            }
            catch (Exception ecc)
            {
                MessageBox.Show(ecc.Message);
            }
            MessageBox.Show("File salvato ma Funzionalità non implementata ancora correttamente.");
        }

        private void creaAnimazioneToolStripMenuItem_Click(object sender, EventArgs e)
        {

            try
            {
                string Dimensione = Microsoft.VisualBasic.Interaction.InputBox("Inserire la dimensione della texture del font", "Dimensione", "", -1, -1);
                int iDimensione = Convert.ToInt32(Dimensione);

                int dx = iDimensione / 16;
                int dy = iDimensione / 16;
                int c = 0;
                m_Grafica.Add(new Animazione(dx, dy));
                m_idAnimazioneSelezionata = m_Grafica.Count - 1;
                m_Animazione = m_Grafica[m_idAnimazioneSelezionata];
                for (int y = 0; y < iDimensione; y += dy)
                {
                    for (int x = 0; x < iDimensione; x += dx)
                    {
                        m_Animazione.AggiungiFotogramma(c, x, y);
                        c++;
                    }
                }
                m_Animazione.AggiungiCollisionBox(0);
                Aggiorna_Label();
            }
            catch (Exception ecc)
            {
                MessageBox.Show(ecc.Message);
            }
        }

        private void creaAnimazione2ToolStripMenuItem_Click(object sender, EventArgs e)
        {
            try
            {
                string Larghezza = Microsoft.VisualBasic.Interaction.InputBox("Inserire la DX del singolo carattere", "LARGHEZZA", "", -1, -1);
                int iLarghezza = Convert.ToInt32(Larghezza);

                string Altezza = Microsoft.VisualBasic.Interaction.InputBox("Inserire la DY del singolo carattere", "ALTEZZA", "", -1, -1);
                int iAltezza = Convert.ToInt32(Altezza);

                int dx = iLarghezza;
                int dy = iAltezza;
                int iDimensioneX = iLarghezza * 16;
                int iDimensioneY = iAltezza * 16;
                int c = 0;
                m_Grafica.Add(new Animazione(dx, dy));
                m_idAnimazioneSelezionata = m_Grafica.Count - 1;
                m_Animazione = m_Grafica[m_idAnimazioneSelezionata];
                for (int y = 0; y < iDimensioneY; y += dy)
                {
                    for (int x = 0; x < iDimensioneX; x += dx)
                    {
                        m_Animazione.AggiungiFotogramma(c, x, y);
                        c++;
                    }
                }
                m_Animazione.AggiungiCollisionBox(0);
                Aggiorna_Label();
            }
            catch (Exception ecc)
            {
                MessageBox.Show(ecc.Message);
            }

        }

        private void inportaDaToolStripMenuItem_Click(object sender, EventArgs e)
        {
            try
            {

                

                /*

                string strValore = "";
                int intValore = -1;

                //tipo_file
                strValore = GetValoreStr(tr.ReadLine());
                if (strValore != "EDITOR_ANIMAZIONI")
                    throw new KeyNotFoundException();

                //versione_engine
                strValore = GetValoreStr(tr.ReadLine());
                if (strValore != "1.1")
                    throw new KeyNotFoundException();

                //dimensione_texture
                intValore = GetValoreInt(tr.ReadLine());
                if (intValore != immagine.Width)
                    throw new KeyNotFoundException();

                m_Grafica.Clear();

                //numero_animazioni
                int iNumeroAnimazioni = GetValoreInt(tr.ReadLine());
                for (int a = 0; a < iNumeroAnimazioni; a++)
                {

                    tr.ReadLine();
                    string sNomeAnimazione = GetValoreStr(tr.ReadLine());
                    int dx_fotogrammi = GetValoreInt(tr.ReadLine());
                    int dy_fotogrammi = GetValoreInt(tr.ReadLine());
                    int fps = GetValoreInt(tr.ReadLine());
                    int n_fotogrammi = GetValoreInt(tr.ReadLine());

                    Animazione animazione = new Animazione(dx_fotogrammi, dy_fotogrammi);
                    animazione.SetNome(sNomeAnimazione);
                    animazione.SetFrameRate(fps);

                    for (int f = 0; f < n_fotogrammi; f++)
                    {
                        int px_fotogramma = GetValoreInt(tr.ReadLine());
                        int py_fotogramma = GetValoreInt(tr.ReadLine());
                        animazione.AggiungiFotogramma(f, px_fotogramma, py_fotogramma);
                    }
                    int n_collisionbox = GetValoreInt(tr.ReadLine());
                    for (int b = 0; b < n_collisionbox; b++)
                    {
                        int px_box = GetValoreInt(tr.ReadLine());
                        int py_box = GetValoreInt(tr.ReadLine());
                        int dx_box = GetValoreInt(tr.ReadLine());
                        int dy_box = GetValoreInt(tr.ReadLine());
                        animazione.AggiungiCollisionBox(b);
                        animazione.SetPxCollisionBox(b, px_box);
                        animazione.SetPyCollisionBox(b, py_box);
                        animazione.SetDxCollisionBox(b, dx_box);
                        animazione.SetDyCollisionBox(b, dy_box);
                    }

                    m_Grafica.Add(animazione);
                }
                tr.Close();
                m_idAnimazioneSelezionata = 0;
                m_Animazione = m_Grafica[m_idAnimazioneSelezionata];
                Aggiorna_Label();
                MessageBox.Show("Animazioni lette correttamente.", "Animazioni", MessageBoxButtons.OK, MessageBoxIcon.Information);
                 * 
                */
            }
            catch (Exception ecc)
            {
                MessageBox.Show(ecc.Message);
            }
        }

        private void step1FormattaToolStripMenuItem_Click(object sender, EventArgs e)
        {
            
            try
            {
                string sRigaLetta;

                openFileDialog1.Filter = "File di Sprite Sheet Packer (*.txt)|*.txt";
                openFileDialog1.ShowDialog();
                string sFileIn = openFileDialog1.FileName;
                string sPathInOut = System.IO.Path.GetDirectoryName(sFileIn);

                string sNomeFileOut = "tmp";
                string sEstensione = System.IO.Path.GetExtension(sFileIn);
                string sFileOut = sPathInOut + "\\" + sNomeFileOut + "_" + sEstensione;

                tr = new System.IO.StreamReader(sFileIn);
                tw = new System.IO.StreamWriter(sFileOut);

                string sNomeAnimazione = "";
                string sIdxFotogramma = "";
                string sCoordinate = "";
                string sFormattata = "";

                List<string> lines = new List<string>();

                while ((sRigaLetta = tr.ReadLine()) != null)
                {
                    sNomeAnimazione = sRigaLetta.Substring(0, sRigaLetta.IndexOf('_'));
                    sIdxFotogramma = sRigaLetta.Substring(sRigaLetta.IndexOf('_') + 1, sRigaLetta.IndexOf('=') - sRigaLetta.IndexOf('_') - 1);
                    sIdxFotogramma = sIdxFotogramma.PadLeft(3, '0');
                    sCoordinate = sRigaLetta.Substring(sRigaLetta.IndexOf('='), sRigaLetta.Length - sRigaLetta.IndexOf('='));
                    sFormattata = sNomeAnimazione + "_" + sIdxFotogramma + sCoordinate;
                    tw.WriteLine(sFormattata);
                    lines.Add(sFormattata);
                }
                tr.Close();
                tw.Close();

                lines.Sort();

                tw = new System.IO.StreamWriter(sFileOut);

                for (int c = 0; c < lines.Count(); c++)
                {
                    sRigaLetta = lines[c];
                    tw.WriteLine(sRigaLetta);
                }
                tw.Close();


                //openFileDialog1.Filter = "File di Sprite Sheet Packer (*.txt)|*.txt";
                //openFileDialog1.ShowDialog();
                //string sFile = openFileDialog1.FileName;
                //string sRigaLetta = "";
                string strNomeAnimazione = "";
                string strNomeAnimazionePrecedente = "";
                string strIdxFotogramma = "";
                string strTmp = "";
                string[] strArray = new string[3];
                int idx = 0;




                m_Grafica.Clear();
                Animazione anim = new Animazione(0, 0);
                bool bPrima = true;

                tr = new System.IO.StreamReader(sFileOut);
                while ((sRigaLetta = tr.ReadLine()) != null)
                {
                    strTmp = sRigaLetta.Substring(0, sRigaLetta.IndexOf('='));
                    strNomeAnimazione = sRigaLetta.Substring(0, strTmp.IndexOf('_'));
                    strIdxFotogramma = sRigaLetta.Substring(sRigaLetta.IndexOf('_') + 1, sRigaLetta.IndexOf('=') - sRigaLetta.IndexOf('_') - 1);
                    strTmp = sRigaLetta.Substring(sRigaLetta.IndexOf('='));
                    strArray = strTmp.Split(' ');
                    int px = Convert.ToInt32(strArray[1]);
                    int py = Convert.ToInt32(strArray[2]);
                    int dx = Convert.ToInt32(strArray[3]);
                    int dy = Convert.ToInt32(strArray[4]);
                    idx = Convert.ToInt32(strIdxFotogramma);

                    if (strNomeAnimazionePrecedente != strNomeAnimazione)
                    {
                        //nuova animazione
                        if (!bPrima)
                            m_Grafica.Add(anim);
                        bPrima = false;
                        anim = new Animazione(dx, dy);
                        anim.SetNome(strNomeAnimazione);
                        //idx = 0;
                        anim.AggiungiFotogramma(idx, px, py);
                        anim.AggiungiCollisionBox(0);
                    }
                    else
                    {
                        //nuovo fotogramma della stessa animazione                        
                        //idx=idx+1;
                        anim.AggiungiFotogramma(idx, px, py);
                    }
                    strNomeAnimazionePrecedente = strNomeAnimazione;

                }
                m_Grafica.Add(anim);
                m_idAnimazioneSelezionata = 0;
                m_Animazione = m_Grafica[m_idAnimazioneSelezionata];
                Aggiorna_Label();
                tr.Close();

                System.IO.File.Delete(sFileOut);
            }
            catch (Exception ecc)
            {                
                MessageBox.Show(ecc.Message);
            }
            finally
            {
               
            }
            tr.Close();
            tw.Close();
        }

        private void numericUpDownAnimazione_ValueChanged(object sender, EventArgs e)
        {

        }

        private void caricaSingoloSetToolStripMenuItem_Click(object sender, EventArgs e)
        {
            MessageBox.Show("Funzione non ancora implementata!", "ATTENZIONE!", MessageBoxButtons.OK);
        }

        private void salvaSingoloSetToolStripMenuItem_Click(object sender, EventArgs e)
        {
            MessageBox.Show("Funzione non ancora implementata!", "ATTENZIONE!", MessageBoxButtons.OK);
        }

        

            
    }
}

